#include "net_func_resource.h"

// 判断是否为IPv4地址的函数
bool is_ipv4_address(const char *ip_str)
{
  if (!ip_str || strlen(ip_str) == 0)
  {
    return false;
  }

  int dots = 0;
  int octets = 0;
  const char *p = ip_str;

  while (*p)
  {
    if (*p == '.')
    {
      dots++;
      if (dots > 3)
        return false;
      octets = 0;
    }
    else if (*p >= '0' && *p <= '9')
    {
      // 构建当前八位组
      if (octets == 0 && *p == '0' && *(p + 1) != '.')
      {
        // 检查是否有前导零（除了单独的"0"）
        return false;
      }
      octets = octets * 10 + (*p - '0');
      if (octets > 255)
      {
        return false;
      }
    }
    else
    {
      // 包含非数字和非点号字符
      return false;
    }
    p++;
  }

  // 必须有3个点号，且最后一个八位组有效
  return (dots == 3 && octets >= 0 && octets <= 255);
}

// 判断是否为IPv6地址的函数（简化版，检查是否有冒号）
bool is_ipv6_address(const char *ip_str)
{
  if (!ip_str || strlen(ip_str) == 0)
  {
    return false;
  }

  // IPv6地址必须包含冒号
  if (strchr(ip_str, ':') == NULL)
  {
    return false;
  }

  // 检查是否包含有效的IPv6字符（0-9, a-f, A-F, :, .）
  const char *p = ip_str;
  while (*p)
  {
    if ((*p >= '0' && *p <= '9') ||
        (*p >= 'a' && *p <= 'f') ||
        (*p >= 'A' && *p <= 'F') ||
        *p == ':' || *p == '.')
    {
      p++;
    }
    else
    {
      return false;
    }
  }

  return true;
}

// 将IPv4字符串转换为uint8_t数组
bool parse_ipv4_to_array(const char *ip_str, uint8_t *ipv4_array)
{
  if (!ip_str || !ipv4_array)
  {
    return false;
  }

  char temp_ip[16];
  strncpy(temp_ip, ip_str, 15);
  temp_ip[15] = '\0';

  char *token = strtok(temp_ip, ".");
  int index = 0;

  while (token != NULL && index < 4)
  {
    // 检查是否有前导零（除了单独的"0"）
    if (strlen(token) > 1 && token[0] == '0')
    {
      return false;
    }

    int value = atoi(token);
    if (value < 0 || value > 255)
    {
      return false;
    }

    ipv4_array[index] = (uint8_t)value;
    index++;
    token = strtok(NULL, ".");
  }

  // 必须有4个八位组
  return (index == 4);
}

// 主函数：解析MQTT服务器地址
int parse_mqtt_server_address(const char *mqtt_broker, uint8_t *mqtt_server_ipv4)
{
  if (!mqtt_broker || !mqtt_server_ipv4)
  {
    return -1; // 错误：输入参数无效
  }

  // 首先检查是否为IPv4地址
  if (is_ipv4_address(mqtt_broker))
  {
    if (parse_ipv4_to_array(mqtt_broker, mqtt_server_ipv4))
    {
      //   printf("检测到IPv4地址: %s\n", mqtt_broker);
      //   printf("转换后的IPv4数组: [%u, %u, %u, %u]\n",
      //          mqtt_server_ipv4[0], mqtt_server_ipv4[1],
      //          mqtt_server_ipv4[2], mqtt_server_ipv4[3]);
      return 4; // 返回IPv4，4字节
    }
    else
    {
      //   printf("IPv4地址格式错误: %s\n", mqtt_broker);
      return -2; // 错误：IPv4格式无效
    }
  }
  // 检查是否为IPv6地址
  else if (is_ipv6_address(mqtt_broker))
  {
    // printf("检测到IPv6地址: %s\n", mqtt_broker);
    // // IPv6地址不能直接转换为uint8_t[4]数组，需要uint8_t[16]数组
    // printf("IPv6地址无法转换为IPv4数组格式\n");
    return 6; // 返回IPv6标识
  }
  // 可能是域名
  else
  {
    // printf("检测到域名或无效IP地址: %s\n", mqtt_broker);
    return 0; // 返回0表示域名或无效格式
  }
}

// 测试函数
void test_mqtt_address_parsing()
{
  char mqtt_broker[256];
  uint8_t mqtt_server_ipv4[4];

  // 测试IPv4地址
  strcpy(mqtt_broker, "192.168.1.100");
  printf("测试: %s\n", mqtt_broker);
  int result = parse_mqtt_server_address(mqtt_broker, mqtt_server_ipv4);
  printf("结果: %d\n\n", result);

  // 测试IPv6地址
  strcpy(mqtt_broker, "2001:0db8:85a3:0000:0000:8a2e:0370:7334");
  printf("测试: %s\n", mqtt_broker);
  result = parse_mqtt_server_address(mqtt_broker, mqtt_server_ipv4);
  printf("结果: %d\n\n", result);

  // 测试域名
  strcpy(mqtt_broker, "mqtt.example.com");
  printf("测试: %s\n", mqtt_broker);
  result = parse_mqtt_server_address(mqtt_broker, mqtt_server_ipv4);
  printf("结果: %d\n\n", result);

  // 测试无效IPv4
  strcpy(mqtt_broker, "999.168.1.100");
  printf("测试: %s\n", mqtt_broker);
  result = parse_mqtt_server_address(mqtt_broker, mqtt_server_ipv4);
  printf("结果: %d\n\n", result);
}
// 生成两个唯一 MAC 地址（直接调用此函数即可）
/* UUID 基地址（F4 系列） */
#define UID_BASE 0x1FFF7A10

/**
 * @brief  用 UUID 生成两个唯一 MAC 地址
 * @param  mac1,out : 第 1 个 MAC（6 字节）
 * @param  mac2,out : 第 2 个 MAC（6 字节）
*/
void mac_generate(uint8_t *mac1, uint8_t *mac2)
{
  uint32_t uid[3];
  uint8_t uid_bytes[12];
  uint32_t hash;
  uint8_t i;

  /* 1. 读出 96-bit UUID */
  uid[0] = *(uint32_t *)(UID_BASE + 0);
  uid[1] = *(uint32_t *)(UID_BASE + 4);
  uid[2] = *(uint32_t *)(UID_BASE + 8);

  /* 2. 拆成 12 字节 */
  for (i = 0; i < 12; i++)
  {
    uid_bytes[i] = (uint8_t)(uid[i / 4] >> (8 * (i % 4)));
  }

  /* 3. 生成第 1 个 MAC（简单哈希） */
  hash = uid[0] ^ uid[1] ^ uid[2];
  mac1[0] = 0x02; /* 本地管理位 */
  mac1[1] = (uint8_t)(hash >> 16);
  mac1[2] = (uint8_t)(hash >> 8);
  mac1[3] = (uint8_t)(hash);
  mac1[4] = uid_bytes[10]; /* UUID 字节 10 */
  mac1[5] = uid_bytes[11]; /* UUID 字节 11 */

  /* 4. 生成第 2 个 MAC（偏移+异或） */
  hash = (uid[0] >> 1) ^ (uid[1] >> 2) ^ (uid[2] >> 3);
  mac2[0] = 0x02;                         /* 本地管理位 */
  mac2[1] = (uint8_t)(hash >> 16) ^ 0x55; /* 加偏移避免重复 */
  mac2[2] = (uint8_t)(hash >> 8) ^ 0xAA;
  mac2[3] = (uint8_t)(hash) ^ 0x5A;
  mac2[4] = uid_bytes[8]; /* UUID 字节 8 */
  mac2[5] = uid_bytes[9]; /* UUID 字节 9 */
}
